class DoublyLinkedListNode {
  constructor(value) {
    this.value = value ? value : 0;
    this.next = null;
    this.prev = null;
  }
}

class DoublyLinkedList {
  constructor() {
    this.size = 0;
    this.head = new DoublyLinkedListNode(null);
    this.tail = new DoublyLinkedListNode(null);
    this.head.next = tail;
    this.tail.prev = head;
  }

  //push() √
  push(value) {
    let pushNode = new DoublyLinkedListNode(value);
    // //不能写curr = this.head.next，因为this.head.next可能不存在
    // let curr = this.head;
    // while (curr.next) {
    //   curr = curr.next;
    // }
    // curr.next = pushNode;
    // pushNode.prev = curr

    let lastNode = tail.prev;
    pushNode.next = this.tail;
    pushNode.prev = lastNode;
    this.tail.prev = pushNode;
    lastNode.next = pushNode;
    this.size += 1;
    return true
  }

  //shift() √
  // shift() {
  //   if (this.head.next === null) {
  //     return false;
  //   }
  //   let curr = this.head.next
  //   curr.next.prev = this.head;
  //   this.head.next = curr.next;
  //   curr.prev = null;
  //   curr.next = null;
  //   this.size -= 1;
  //   return true;
  // }

  //unshift() √
  unshift(value) {
    if (this.head.next === null) {
      return false;
    }
    let insertNode = new DoublyLinkedListNode(value);
    let curr = this.head.next;
    insertNode.next = curr;
    insertNode.prev = this.head;
    curr.prev = insertNode;
    this.head.next = insertNode;
    this.size += 1;
    return true;
  }

  //pop() √
  // pop() {
  //   //需要用一个新的节点来保存最后一个节点。用于最后的返回
  //   if (!this.head.next) {
  //     return false;
  //   }
  //   // let curr = this.head.next;
  //   // while (curr.next) {
  //   //   curr = curr.next;
  //   // }
  //   // curr.prev.next = null;
  //   // curr.prev = null;

  //   let lastNode = this.tail.prev;
  //   let prevNode = lastNode.prev;

  //   this.tail.prev = prevNode;
  //   prevNode.next = this.tail;
  //   this.size -= 1;
  //   return curr;
  // }

  getIndexNode(index) {
    let indexNode = this.head;
    let flag = 0;
    while (flag !== index + 1) {
      indexNode = indexNode.next;
      flag += 1;
    }
    return indexNode;
  }
  //insert() √
  // insert(value, index) {
  //   if (index < 0 || index > this.size) {
  //     return false;
  //   }
  //   let insertNode = new DoublyLinkedListNode(value);
  //   let indexNode = this.getIndexNode(index);
  //   insertNode.next = indexNode;
  //   insertNode.prev = indexNode.prev;
  //   //注意顺序，防止丢失链表
  //   indexNode.prev.next = insertNode;
  //   indexNode.prev = insertNode;
  //   this.size += 1;
  //   return true;
  // }

  //remove() √
  // remove(index) {
  //   if (this.head.next === null || index > this.size) {
  //     return false;
  //   }
  //   let current = this.getIndexNode(index);

  //   let prevNode = current.prev;
  //   let nextNode = current.next;
  //   prevNode.next = nextNode;
  //   nextNode.prev = prevNode;
  //   current.next = null;
  //   current.prev = null;
  //   this.size--;

  //   return true;
  // }

  //printList() √
  printList() {
    let resultArr = []
    if (!this.head.next) {
      return resultArr;
    }
    let curr = this.head.next;
    while (curr) {
      if (curr.value !== null) {
        resultArr.push(curr.value);
      }
      curr = curr.next;
    }
    return resultArr;
  }
}
let list = new DoublyLinkedList;
list.push(1)
list.push(2)
list.printList();
